home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / SE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-14  |  14.8 KB  |  672 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. #include "global.h"
  5. #include "edit.h"
  6. #include "comm.h"
  7. #include "debug.h"
  8. #include "icon.h"
  9. #include "menu.h"
  10. #include "obj.h"
  11. #include "rsc.h"
  12. #include "se.h"
  13.  
  14. #ifdef DEBUG
  15. #undef DEBUG_SE
  16. #endif
  17.  
  18. /* exprortierte Variablem *****************************************************/
  19. GLOBAL ShellEntry se_shells[SHELLANZ];    /* 0 - 4 : qed sucht Shell */
  20.                                                     /* 5        : Shell sucht qed */
  21.  
  22. GLOBAL BOOLEAN     se_activ;                /* haben wir Kontakt zur Shell? */
  23. GLOBAL BOOLEAN        se_autosave,
  24.                         se_autosearch;
  25.  
  26. typedef struct _separm
  27. {
  28.     WORD        id;
  29.     WORD        shellCmd;
  30.     WORD        editCmd;
  31.     WORD        se_version;
  32.     UBYTE        progName[25];
  33. } SEPARMS;
  34.  
  35.  
  36. /* lokale Variablem **********************************************************/
  37. LOCAL SEPARMS    shellParm,
  38.                     editParm;
  39. LOCAL WORD        aktiv;                /* Nummer der aktiven Shell (0..SHELLANZ - 1) */
  40. LOCAL WORD        menu_len;
  41. LOCAL LONG        timer;                /* wird hochgezählt */
  42. LOCAL    BOOLEAN    wait_for_answer;    /* TRUE, wenn auf SE_OK/_ACK gewartet wird */
  43. LOCAL UBYTE        orgMenu[7][25];
  44.  
  45.  
  46. /*****************************************************************************/
  47. #define WAITTIME    2000                /* Zeit in ms, die qed auf ein SE_ACK wartet */
  48.  
  49. /* lokale Prototypen */
  50. LOCAL VOID        sendOK(VOID);
  51. LOCAL VOID        sendACK(BOOLEAN ok);
  52. LOCAL VOID        sendCmd(WORD cmd, WORD bit);
  53.  
  54.  
  55. LOCAL VOID    setupMakefile(VOID)
  56. {
  57.     FILENAME n = "";
  58.  
  59.     if (se_shells[aktiv].Makefile[0] == EOS)
  60.         menu_text(menu, MSMAKEFILE, orgMenu[0]);
  61.     else
  62.     {
  63.         file_name(se_shells[aktiv].Makefile, n, FALSE);
  64.         fillup_menu(MSMAKEFILE, n, 2);
  65.     }
  66. }
  67.  
  68.  
  69. LOCAL VOID setTitel(UBYTE *titel)
  70. {
  71.     UBYTE str[25] = " ";
  72.  
  73.     strcat(str, titel);
  74.     strcat(str, " ");
  75.     menu_bar(menu, 0);
  76.     menu[2].ob_width = menu_len + (short)strlen(str) * sys_wchar;
  77.     menu[MSHELL].ob_width = (short)strlen(str) * sys_wchar;
  78.     strcpy(menu[MSHELL].ob_spec.free_string, str);
  79.     menu_bar(menu, 1);
  80.     updt_menu();
  81. }
  82.  
  83. GLOBAL VOID setup_semenu(VOID)
  84. {
  85.     WORD    i;
  86.  
  87.     if (se_activ)
  88.     {
  89.         setupMakefile();
  90.         set_menu(MSQUIT, TRUE);
  91.         set_menu(MSMAKEFILE, (shellParm.editCmd & _ESMAKE));
  92.         set_menu(MSCOMP, (shellParm.editCmd & _ESCOMPILE));
  93.         set_menu(MSMAKE, (shellParm.editCmd & _ESMAKE));
  94.         set_menu(MSMAKEALL, (shellParm.editCmd & _ESMAKEALL));
  95.         set_menu(MSLINK, (shellParm.editCmd & _ESLINK));
  96.         set_menu(MSEXEC, (shellParm.editCmd & _ESEXEC));
  97.         set_menu(MSMAKEEXEC, (shellParm.editCmd & _ESMAKEEXEC));
  98.     }
  99.     else
  100.     {
  101.         for (i = MSQUIT; i <= MSMAKEEXEC; i++)
  102.             set_menu(i, FALSE);
  103.     }
  104. }
  105.  
  106.  
  107. LOCAL VOID resetShellMenu(VOID)
  108. {
  109.     WORD    i;
  110.  
  111.     setTitel("Shell");
  112.     menu_text(menu, MSMAKEFILE, orgMenu[0]);
  113.     for (i = MSCOMP; i <= MSMAKEEXEC; i++)
  114.         menu_text(menu, i, orgMenu[i - MSCOMP + 1]);
  115. }
  116.  
  117.  
  118. GLOBAL VOID    timer_se(VOID)
  119. {
  120.     if (wait_for_answer)
  121.     {
  122.         timer += 500;
  123.         if (timer > WAITTIME)
  124.         {
  125.             timer = 0;
  126.             wait_for_answer = FALSE;
  127.             se_activ = FALSE;
  128.             note(1, SENOANS);
  129.             setTitel("Shell");
  130.         }
  131.     }
  132. }
  133.  
  134.  
  135. LOCAL VOID set_timer(VOID)
  136. {
  137.     timer = 0;
  138.     wait_for_answer = TRUE;
  139. }
  140.  
  141.  
  142. LOCAL VOID reset_timer(VOID)
  143. {
  144.     timer = 0;
  145.     wait_for_answer = FALSE;
  146. }
  147.  
  148. /* Shell -> Editor ************************************************************/
  149.  
  150. /* forward Dekl. */
  151. LOCAL VOID    sendESQUIT(VOID);
  152. LOCAL VOID    sendCmd(WORD cmd, WORD bit);
  153.  
  154.  
  155. /* Antwort auf SE_INIT */
  156. LOCAL VOID    sendOK(VOID)
  157. {
  158.     if (shellParm.editCmd & _ESOK)
  159.     {
  160. #ifdef DEBUG_SE
  161.     Debug("qed: sendOK -> %d\n", shellParm.id);
  162. #endif
  163.         memset(msgbuff, 0, (WORD)sizeof(msgbuff));
  164.         msgbuff[0] = ES_OK;
  165.         msgbuff[1] = editParm.id;
  166.         msgbuff[3] = editParm.shellCmd;
  167.         msgbuff[5] = editParm.editCmd;
  168.         msgbuff[6] = SEPROTOVERSION;
  169.         msgbuff[7] = shellParm.id;
  170.         send_msg(shellParm.id);
  171.     }
  172. }
  173.  
  174.  
  175. LOCAL VOID    sendACK(BOOLEAN ok)
  176. {
  177.     if (shellParm.editCmd & _ESACK)
  178.     {
  179. #ifdef DEBUG_SE
  180.     Debug("qed: sendAck -> %d\n", shellParm.id);
  181. #endif
  182.         memset(msgbuff, 0, (WORD)sizeof(msgbuff));
  183.         msgbuff[0] = ES_ACK;
  184.         msgbuff[1] = editParm.id;
  185.         msgbuff[3] = ok;
  186.         send_msg(shellParm.id);
  187.     }
  188. }
  189.  
  190.  
  191. GLOBAL VOID hndl_se(WORD *msg)
  192. {
  193.     UBYTE         datei[255], fehler[255], str[9], *p, *p2;
  194.     WORD            icon, i, d;
  195.     ERRINFO        *error;
  196.     SEMENUINFO    *pmenu;
  197.  
  198.     switch (msg[0])
  199.     {
  200.         case SE_INIT :
  201. #ifdef DEBUG_SE
  202.     Debug("qed: SE_INIT von %d\n", msg[1]);
  203.     Debug("      shellCmd = %d\n", msg[3]);
  204.     Debug("      editCmd  = %d\n", msg[5]);
  205.     Debug("      version  = %d\n", msg[6]);
  206. #endif
  207.             if (se_activ)
  208.                 sendESQUIT();
  209.             shellParm.id = msg[1];
  210.             shellParm.shellCmd = msg[3];
  211.             shellParm.editCmd  = msg[5];
  212.             shellParm.se_version = msg[6];
  213.             sendOK();
  214.             se_activ = TRUE;
  215.  
  216.             /* Wir versuchen den GEM-Namen des Senders zu ermitteln */
  217.             if (magx)
  218.             {
  219.                 /* MagiC-Special, funkt auch, wenn es kein appl_search gibt */
  220.                 sprintf(str, "? %cXXXXX", (char) shellParm.id);
  221.                 str[1] = '\0';
  222.                 appl_find(str);
  223.             }
  224.             else
  225.             if ((appl_xgetinfo(4, &d, &d, &i, &d)) && (i == 1))    /* gibts appl_search? */
  226.             {
  227.                 WORD    type, id;
  228.  
  229.                 i = appl_search( 0, str, &type, &id);
  230.                 while (i != 0)
  231.                 {
  232.                     if (type == 2 && id == shellParm.id)
  233.                         break;
  234.                     i = appl_search( 1, str, &type, &id);
  235.                 }
  236.             }
  237.             else
  238.                 strcpy(str, "Shell");
  239.  
  240.             aktiv = SHELLANZ - 1;
  241.             if ((p = strchr(str, ' ')) != NULL)        /* Blanks am Ende abschneiden */
  242.                 *p = EOS;
  243.             for (i = 0; i < SHELLANZ - 1; i++)        /* Shell eine der angemeldeten? -> Makefile */
  244.             {
  245.                 if (strcmp(str, se_shells[i].Name) == 0)
  246.                     aktiv = i;
  247.             }
  248.             if (aktiv == SHELLANZ - 1)                    /* Shell nicht angemeldet */
  249.             {
  250.                 strcpy(se_shells[aktiv].Name, str);
  251.                 strcpy(se_shells[aktiv].Makefile, "");
  252.             }
  253.             setTitel(se_shells[aktiv].Name);
  254.             break;
  255.         case SE_OK        :
  256.             reset_timer();
  257.             shellParm.id         = msg[1];
  258.             shellParm.shellCmd = msg[3];
  259.             shellParm.editCmd  = msg[5];
  260.             shellParm.se_version = msg[6];
  261.             se_activ = TRUE;
  262.             setTitel(se_shells[aktiv].Name);
  263.             break;
  264.         case SE_ACK     :
  265.             reset_timer();
  266.             break;
  267.         case SE_OPEN    :
  268.             p = *(UBYTE **)(msg + 3);
  269.             if (p != NULL)
  270.                 strcpy(datei, p);
  271.             sendACK(TRUE);
  272.             if ((strlen(datei) > 0) && file_exist(datei))
  273.             {
  274.                 icon = load_edit(datei, FALSE, -1, -1, NULL);
  275.                 if (icon > 0)
  276.                     do_icon(icon, DO_OPEN);
  277.             }
  278.             break;
  279.         case SE_ERROR :
  280.             error = *(ERRINFO **)(msg + 3);
  281.             if (error != NULL)
  282.             {
  283.                 strcpy(datei, error->errFile);
  284.                 strcpy(fehler, error->errMess);
  285.                 desire_x = error->errRow - 1;
  286.                 desire_y = error->errLine - 1;
  287.             }
  288.             sendACK(TRUE);
  289.             if ((strlen(datei) > 0) && file_exist(datei))
  290.             {
  291.                 icon = load_edit(datei, FALSE, -1, -1, NULL);
  292.                 if (icon > 0)
  293.                 {
  294.                     UBYTE    str[256];
  295.  
  296.                     strcpy(str, STRING(ERRORSTR));
  297.                     strcat(str, fehler);
  298.                     set_info(get_text(icon), str);
  299.                     do_icon(icon, DO_OPEN);
  300.                     Icon_edit(icon, DO_GOTO);
  301.                 }
  302.             }
  303.             break;
  304.         case SE_ERRFILE :
  305.             p = *(UBYTE **)(msg + 5);
  306.             p2 = *(UBYTE **)(msg + 3);
  307.             if ((p != NULL) && (p2 != NULL))
  308.             {
  309.                 strcpy(datei, p);
  310.                 strcpy(fehler, p2);
  311.             }
  312.             sendACK(TRUE);
  313.             if ((strlen(datei) > 0) && file_exist(datei))
  314.             {
  315.                 icon = load_edit(datei, FALSE, -1, -1, NULL);
  316.                 if (icon > 0)
  317.                     do_icon(icon, DO_OPEN);
  318.             }
  319.             if ((strlen(fehler) > 0) && file_exist(fehler))
  320.             {
  321.                 icon = load_edit(fehler, FALSE, -1, -1, NULL);
  322.                 if (icon > 0)
  323.                 {
  324.                     do_icon(icon, DO_ABAND);
  325.                     desire_x = 0;
  326.                     desire_y = 0;
  327.                     Icon_edit(icon, DO_GOTO);
  328.                 }
  329.             }
  330.             break;
  331.         case SE_PROJECT :
  332.             p = *(UBYTE **)(msg + 3);
  333.             if (p != NULL)
  334.                 strcpy(datei, p);
  335.             else
  336.                 strcpy(datei, "");
  337.              sendACK(TRUE);
  338.             if (file_exist(datei))
  339.             {
  340.                 strcpy(se_shells[aktiv].Makefile, datei);
  341.                 setupMakefile();
  342.             }
  343.              break;
  344.         case SE_QUIT :
  345.             se_activ = FALSE;
  346.             resetShellMenu();
  347.             break;
  348.         case SE_CLOSE :
  349.             if (shellParm.se_version >= 0x101)
  350.             {
  351.                 p = *(UBYTE **)(msg + 3);
  352.                 if ((p != NULL) && (strlen(p) > 0))
  353.                 {
  354.                     strcpy(datei, p);
  355.                      sendACK(TRUE);
  356.                     close_edit(datei, msg[5]);
  357.                 }
  358.             }
  359.             else
  360.             {
  361.                  sendACK(TRUE);
  362.                 close_edit("*.*", 1);
  363.             }
  364.              break;
  365.         case SE_MENU :
  366.             pmenu = *(SEMENUINFO **)(msg + 3);
  367.             if (pmenu != NULL)
  368.             {
  369.                 if ((pmenu->compStr != NULL) && (strlen(pmenu->compStr) > 0))
  370.                     fillup_menu(MSCOMP, pmenu->compStr, 2);
  371.                 if ((pmenu->makeStr != NULL) && (strlen(pmenu->makeStr) > 0))
  372.                     fillup_menu(MSMAKE, pmenu->makeStr, 2);
  373.                 if ((pmenu->makeAllStr != NULL) && (strlen(pmenu->makeAllStr) > 0))
  374.                     fillup_menu(MSMAKEALL, pmenu->makeAllStr, 2);
  375.                 if ((pmenu->linkStr != NULL) && (strlen(pmenu->linkStr) > 0))
  376.                     fillup_menu(MSLINK, pmenu->linkStr, 2);
  377.                 if ((pmenu->execStr != NULL) && (strlen(pmenu->execStr) > 0))
  378.                     fillup_menu(MSEXEC, pmenu->execStr, 2);
  379.                 if ((pmenu->makeExecStr != NULL) && (strlen(pmenu->makeExecStr) > 0))
  380.                     fillup_menu(MSMAKEEXEC, pmenu->makeExecStr, 2);
  381.                 
  382.                 if (shellParm.se_version >= 0x104)
  383.                     if ((pmenu->progName != NULL) && (strlen(pmenu->progName) > 0))
  384.                         setTitel(pmenu->progName);
  385.  
  386.                  sendACK(TRUE);
  387.             }
  388.             break;
  389.         default:
  390.             break;
  391.     } /* switch */
  392. }
  393.  
  394.  
  395. /* Editor -> Shell ************************************************************/
  396.  
  397.  
  398. LOCAL VOID    sendESQUIT(VOID)
  399. {
  400.     memset(msgbuff, 0, (WORD)sizeof(msgbuff));
  401.     msgbuff[0] = ES_QUIT;
  402.     msgbuff[1] = editParm.id;
  403.     (VOID) send_msg(shellParm.id);
  404.     se_activ = FALSE;
  405. }
  406.  
  407.  
  408. LOCAL VOID    sendESINIT(WORD app)
  409. {
  410.     memset(msgbuff, 0, (WORD)sizeof(msgbuff));
  411.     msgbuff[0] = ES_INIT;
  412.     msgbuff[1] = editParm.id;
  413.     msgbuff[3] = editParm.shellCmd;
  414.     msgbuff[5] = editParm.editCmd;
  415.     msgbuff[6] = SEPROTOVERSION;
  416.     send_msg(app);
  417. }
  418.  
  419.  
  420. LOCAL VOID    sendCmd(WORD cmd, WORD bit)
  421. {
  422.     if (shellParm.editCmd & bit)
  423.     {
  424.         memset(msgbuff, 0, (WORD)sizeof(msgbuff));
  425.         msgbuff[0] = cmd;
  426.         msgbuff[1] = editParm.id;
  427.         if (global_str1[0] != EOS)
  428.             *(UBYTE **) &msgbuff[3] = global_str1;
  429.         else
  430.             *(UBYTE **) &msgbuff[3] = NULL;
  431.         if (!send_msg(shellParm.id))
  432.         {
  433.             se_activ = FALSE;
  434.             setTitel("Shell");
  435.             note(1, SENOANS);
  436.             return;
  437.         }
  438.         set_timer();
  439.     }
  440. }
  441.  
  442. LOCAL VOID get_filename(WORD icon)
  443. {
  444.     TEXTP     t_ptr;
  445.  
  446.     if (icon != -1)
  447.     {
  448.         t_ptr = get_text(icon);
  449.         strcpy(global_str1, t_ptr->filename);
  450.     }
  451.     else
  452.         strcpy(global_str1, "");
  453. }
  454.  
  455. LOCAL BOOLEAN such_shell(VOID)
  456. {
  457.     WORD    i, j;
  458.     UBYTE    name[9];
  459.  
  460.     for (i = 0; i < SHELLANZ - 1; i++)
  461.     {
  462.         strcpy(name, se_shells[i].Name);
  463.         if (name[0])
  464.         {
  465.             for (j = (short) strlen(name); j < 8; j++)
  466.                 strcat(name, " ");
  467.             j = appl_find(name);
  468.             if (j > 0)
  469.             {
  470.                 aktiv = i;
  471.                 sendESINIT(j);
  472.                 set_timer();
  473.                 return TRUE;
  474.             }
  475.         }
  476.     }
  477.     return FALSE;
  478. }
  479.  
  480. LOCAL VOID se_options(VOID)
  481. {
  482.     WORD    i, antw;
  483.     UBYTE    tmp[30];
  484.  
  485.     if (se_activ)
  486.     {
  487.         sprintf(tmp, "%s, SE-Version %x", se_shells[aktiv].Name, shellParm.se_version);
  488.         objc_setstring(seoptions, SESTATUS, tmp);
  489.     }
  490.     else
  491.         objc_setstring(seoptions, SESTATUS, "--");
  492.     
  493.     for (i = 0; i < SHELLANZ - 1; i++)
  494.         objc_setstring(seoptions, SENAME1 + i, se_shells[i].Name);
  495.  
  496.     select_objc(seoptions, SESAVE, se_autosave);
  497.     select_objc(seoptions, SESEARCH, se_autosearch);
  498.  
  499.     if (se_activ)
  500.     {
  501.         do_flags(seoptions, SEOK, DEFAULT);
  502.         undo_flags(seoptions, SESUCH, DEFAULT);
  503.     }
  504.     else
  505.     {
  506.         undo_flags(seoptions, SEOK, DEFAULT);
  507.         do_flags(seoptions, SESUCH, DEFAULT);
  508.     }
  509.     
  510.     Arrow_mouse();
  511.     antw = HndlDial(seoptions, SENAME1, FALSE, NULL, NULL);
  512.     Last_mouse();
  513.     if ((antw == SEOK) || (antw == SESUCH))
  514.     {
  515.         for (i = 0; i < SHELLANZ - 1; i++)
  516.             objc_getstring(seoptions, SENAME1 + i, se_shells[i].Name);
  517.  
  518.         se_autosave = get_select(seoptions, SESAVE);
  519.         se_autosearch = get_select(seoptions, SESEARCH);
  520.  
  521.         if (antw == SESUCH)
  522.         {
  523.             if (se_activ)
  524.             {
  525.                 antw = note(2, SEONLINE);
  526.                 if (antw == 2)
  527.                     return;
  528.                 else
  529.                 {
  530.                     sendESQUIT();
  531.                     setTitel("Shell");
  532.                 }
  533.             }
  534.             if (!such_shell())
  535.                 note(1, SENOTFOUND);
  536.         }
  537.     }
  538. }
  539.  
  540. LOCAL VOID do_sesave(WINDP window)
  541. {
  542.     if (window != NULL)
  543.     {
  544.         TEXTP    t_ptr;
  545.         
  546.         t_ptr = get_text(window->link);
  547.         if ((t_ptr!= NULL) && (t_ptr->moved != 0))
  548.             do_icon(window->link, DO_SAVE);
  549.     }
  550. }
  551.  
  552. GLOBAL VOID hndl_es(WORD item)
  553. {
  554.     FSEL        fsel = {"", "*.*"};
  555.     PATH        name = "";
  556.     FILENAME n = "";
  557.     WINDOWP    window;
  558.     WORD        top_icon = -1;
  559.     
  560.     if (item == MSOPT)
  561.         se_options();
  562.  
  563.     if (!se_activ)
  564.         return ;
  565.  
  566.     window = top();
  567.     if (window != NULL && window->class == CLASS_EDIT)
  568.         top_icon = window->link;
  569.  
  570.     switch (item)
  571.     {
  572.         case MSQUIT :
  573.             sendESQUIT();
  574.             resetShellMenu();
  575.             break;
  576.         case MSMAKEFILE:
  577.             if (global_shift && se_shells[aktiv].Makefile[0] != EOS)    /* Makefile löschen */
  578.             {
  579.                 se_shells[aktiv].Makefile[0] = EOS;
  580.                 updt_menu();
  581.                 if (shellParm.se_version >= 0x101)
  582.                 {
  583.                     strcpy(global_str1, "");
  584.                     sendCmd(ES_PROJECT, _ESPROJECT);
  585.                 }
  586.                 break;
  587.             }
  588.             if (se_shells[aktiv].Makefile[0] != EOS)
  589.             {
  590.                 file_name(se_shells[aktiv].Makefile, n, FALSE);
  591.                 set_fsel_path(se_shells[aktiv].Makefile);
  592.             }
  593.             strcpy(fsel.name, n);
  594.             if (select_file(&fsel, name, STRING(FINDMKSTR)))
  595.             {
  596.                 strcpy(se_shells[aktiv].Makefile, name);
  597.                 setupMakefile();
  598.                 strcpy(global_str1, se_shells[aktiv].Makefile);
  599.                 sendCmd(ES_PROJECT, _ESPROJECT);
  600.             }
  601.             break;
  602.         case MSCOMP :
  603.             if (se_autosave)
  604.                 do_sesave(window);
  605.             get_filename(top_icon);
  606.             if ((global_str1[0] != EOS) || (shellParm.se_version >= 0x103))
  607.                 sendCmd(ES_COMPILE, _ESCOMPILE);
  608.             break;
  609.         case MSMAKE :
  610.             if (se_autosave)
  611.                 get_all_windows(CLASS_EDIT, SRCH_ANY, do_sesave);
  612.             strcpy(global_str1, se_shells[aktiv].Makefile);
  613.             sendCmd(ES_MAKE, _ESMAKE);
  614.             break;
  615.         case MSMAKEALL :
  616.             if (se_autosave)
  617.                 get_all_windows(CLASS_EDIT, SRCH_ANY, do_sesave);
  618.             strcpy(global_str1, se_shells[aktiv].Makefile);
  619.             sendCmd(ES_MAKEALL, _ESMAKEALL);
  620.             break;
  621.         case MSLINK :
  622.             get_filename(top_icon);
  623.             sendCmd(ES_LINK, _ESLINK);
  624.             break;
  625.         case MSEXEC :
  626.             get_filename(top_icon);
  627.             sendCmd(ES_EXEC, _ESEXEC);
  628.             break;
  629.         case MSMAKEEXEC :
  630.             if (se_autosave)
  631.                 get_all_windows(CLASS_EDIT, SRCH_ANY, do_sesave);
  632.             strcpy(global_str1, se_shells[aktiv].Makefile);
  633.             sendCmd(ES_MAKEEXEC, _ESMAKEEXEC);
  634.             break;
  635.     } /* switch */
  636. }
  637.  
  638.  
  639. GLOBAL VOID    init_se(VOID)
  640. {
  641.     WORD    i;
  642.     
  643.     se_activ = FALSE;
  644.     menu_len = menu[2].ob_width - menu[MSHELL].ob_width;
  645.     setTitel("Shell");
  646.  
  647.     /* Menüeinträge sichern */
  648.     strcpy(orgMenu[0], (UBYTE *)get_obspec(menu, MSMAKEFILE));
  649.     for (i = MSCOMP; i <= MSMAKEEXEC; i++)
  650.         strcpy(orgMenu[i - MSCOMP + 1], (UBYTE *)get_obspec(menu, i));
  651.  
  652.     shellParm.id         = -1;
  653.     shellParm.shellCmd = 0;
  654.     shellParm.editCmd  = 0;
  655.  
  656.     editParm.id          = gl_apid;
  657.     editParm.shellCmd  = (_SEINIT|_SEOK|_SEACK|_SEQUIT|_SEOPEN|_SEERROR|_SEERRFILE|_SEPROJECT|_SECLOSE|_SEMENU);
  658.     editParm.editCmd     = (_ESINIT|_ESOK|_ESACK|_ESQUIT|_ESCOMPILE|_ESMAKE|_ESMAKEALL|_ESLINK|_ESEXEC|_ESMAKEEXEC|_ESPROJECT);
  659.  
  660.     setupMakefile();
  661.  
  662.     if (se_autosearch)
  663.         such_shell();
  664. }
  665.  
  666. GLOBAL VOID term_se(VOID)
  667. {
  668.     if (se_activ && (shellParm.editCmd & _ESQUIT))
  669.         sendESQUIT();
  670. }
  671.  
  672.